ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ: ಸ್ಟ್ರೀಮ್ ಮೆಮೊರಿ ಆಪ್ಟಿಮೈಸೇಶನ್

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಇಟರೇಬಲ್‌ಗಳು ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ವ್ಯವಸ್ಥೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ. map, filter, ಮತ್ತು reduce ನಂತಹ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳು ಈ ಅಡಿಪಾಯದ ಮೇಲೆ ನಿರ್ಮಿತವಾಗಿದ್ದು, ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಶೀಲ ಡೇಟಾ ರೂಪಾಂತರಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಈ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಸರಳವಾಗಿ ಚೈನ್ ಮಾಡುವುದರಿಂದ ಗಮನಾರ್ಹ ಮೆಮೊರಿ ಓವರ್‌ಹೆಡ್ ಉಂಟಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. ಈ ಲೇಖನವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಬಳಸುವಾಗ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ, ಸ್ಟ್ರೀಮ್ ಪ್ರಕ್ರಿಯೆ ಮತ್ತು ಲೇಜಿ ಇವ್ಯಾಲ್ಯುಯೇಷನ್ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತದೆ. ನಾವು ವಿವಿಧ ಪರಿಸರಗಳಲ್ಲಿ ಮೆಮೊರಿ ಫುಟ್‌ಪ್ರಿಂಟ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ತಂತ್ರಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತೇವೆ.

ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಇಟರೇಬಲ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಇಟರೇಬಲ್‌ಗಳ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪರಿಶೀಲಿಸೋಣ.

ಇಟರೇಬಲ್‌ಗಳು

ಒಂದು ಇಟರೇಬಲ್ ಎಂದರೆ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದ್ದು ಅದು ತನ್ನ ಇಟರೇಷನ್ ನಡವಳಿಕೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ for...of ಕನ್‌ಸ್ಟ್ರಕ್ಟ್‌ನಲ್ಲಿ ಯಾವ ಮೌಲ್ಯಗಳ ಮೇಲೆ ಲೂಪ್ ಮಾಡಲಾಗುತ್ತದೆ. ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಇಟರೇಬಲ್ ಆಗಿದ್ದರೆ, ಅದು @@iterator ಮೆಥಡ್ (Symbol.iterator ಕೀ ಹೊಂದಿರುವ ಮೆಥಡ್) ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಅದು ಒಂದು ಇಟರೇಟರ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.

            const iterable = {
  data: [1, 2, 3],
  [Symbol.iterator]() {
    let index = 0;
    return {
      next: () => {
        if (index < this.data.length) {
          return { value: this.data[index++], done: false };
        } else {
          return { value: undefined, done: true };
        }
      }
    };
  }
};

for (const value of iterable) {
  console.log(value); // Output: 1, 2, 3
}

            

              
                Copy
              
            
          

ಇಟರೇಟರ್‌ಗಳು

ಇಟರೇಟರ್ ಎನ್ನುವುದು ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದ್ದು ಅದು ಮೌಲ್ಯಗಳ ಅನುಕ್ರಮವನ್ನು ಒಂದೊಂದಾಗಿ ಒದಗಿಸುತ್ತದೆ. ಇದು next() ಮೆಥಡ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಅದು ಎರಡು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ: value (ಅನುಕ್ರಮದಲ್ಲಿನ ಮುಂದಿನ ಮೌಲ್ಯ) ಮತ್ತು done (ಅನುಕ್ರಮವು ಮುಗಿದಿದೆಯೇ ಎಂದು ಸೂಚಿಸುವ ಬೂಲಿಯನ್). ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೂಪಿಂಗ್ ಮತ್ತು ಡೇಟಾ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರಲ್ಲಿ ಇಟರೇಟರ್‌ಗಳು ಕೇಂದ್ರವಾಗಿವೆ.

ಸವಾಲು: ಚೈನ್ಡ್ ಇಟರೇಟರ್‌ಗಳಲ್ಲಿ ಮೆಮೊರಿ ಓವರ್‌ಹೆಡ್

ಕೆಳಗಿನ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸಿ: ನೀವು API ಯಿಂದ ಪಡೆದ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬೇಕು, ಅಮಾನ್ಯ ನಮೂದುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ ಮತ್ತು ನಂತರ ಮಾನ್ಯ ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸುವ ಮೊದಲು ರೂಪಾಂತರಿಸಬೇಕು. ಒಂದು ಸಾಮಾನ್ಯ ವಿಧಾನವು ಈ ರೀತಿ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳನ್ನು ಚೈನ್ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರಬಹುದು:

            const data = fetchData(); // Assume fetchData returns a large array

const processedData = data
  .filter(item => isValid(item))
  .map(item => transform(item))
  .slice(0, 10); // Take only the first 10 results for display

            

              
                Copy
              
            
          

ಈ ಕೋಡ್ ಓದಲು ಸುಲಭ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತವಾಗಿದ್ದರೂ, ಇದು ಒಂದು ನಿರ್ಣಾಯಕ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಯಿಂದ ಬಳಲುತ್ತದೆ: ಮಧ್ಯಂತರ ಅರೇ ರಚನೆ. ಪ್ರತಿಯೊಂದು ಹೆಲ್ಪರ್ ಮೆಥಡ್ (filter, map) ತನ್ನ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಹೊಸ ಅರೇಯನ್ನು ರಚಿಸುತ್ತದೆ. ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ, ಇದು ಗಮನಾರ್ಹವಾದ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮತ್ತು ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಷನ್ ಓವರ್‌ಹೆಡ್‌ಗೆ ಕಾರಣವಾಗಬಹುದು, ಇದು ಅಪ್ಲಿಕೇಶನ್ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ ಮತ್ತು ಸಂಭಾವ್ಯವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

data ಅರೇಯಲ್ಲಿ ಲಕ್ಷಾಂತರ ನಮೂದುಗಳಿವೆ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. filter ಮೆಥಡ್ ಕೇವಲ ಮಾನ್ಯ ಐಟಂಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಹೊಸ ಅರೇಯನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು ಇನ್ನೂ ಗಣನೀಯ ಸಂಖ್ಯೆಯಲ್ಲಿರಬಹುದು. ನಂತರ, map ಮೆಥಡ್ ರೂಪಾಂತರಿಸಿದ ಡೇಟಾವನ್ನು ಹಿಡಿದಿಡಲು ಮತ್ತೊಂದು ಅರೇಯನ್ನು ರಚಿಸುತ್ತದೆ. ಕೊನೆಯಲ್ಲಿ ಮಾತ್ರ, slice ಒಂದು ಸಣ್ಣ ಭಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಮಧ್ಯಂತರ ಅರೇಗಳಿಂದ ಸೇವಿಸಲ್ಪಟ್ಟ ಮೆಮೊರಿಯು ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬೇಕಾದ ಮೆಮೊರಿಗಿಂತ ಬಹಳಷ್ಟು ಹೆಚ್ಚಿರಬಹುದು.

ಪರಿಹಾರಗಳು: ಸ್ಟ್ರೀಮ್ ಪ್ರಕ್ರಿಯೆಯೊಂದಿಗೆ ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು

ಮೆಮೊರಿ ಓವರ್‌ಹೆಡ್ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, ನಾವು ಮಧ್ಯಂತರ ಅರೇಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ತಂತ್ರಗಳು ಮತ್ತು ಲೇಜಿ ಇವ್ಯಾಲ್ಯುಯೇಷನ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಈ ಗುರಿಯನ್ನು ಸಾಧಿಸಲು ಹಲವಾರು ವಿಧಾನಗಳಿವೆ:

1. ಜನರೇಟರ್‌ಗಳು

ಜನರೇಟರ್‌ಗಳು ಒಂದು ವಿಶೇಷ ರೀತಿಯ ಫಂಕ್ಷನ್‌ಗಳಾಗಿದ್ದು, ಅವನ್ನು ವಿರಾಮಗೊಳಿಸಿ ಮತ್ತೆ ಮುಂದುವರಿಸಬಹುದು, ಇದು ನಿಮಗೆ ಬೇಡಿಕೆಯ ಮೇಲೆ ಮೌಲ್ಯಗಳ ಅನುಕ್ರಮವನ್ನು ಉತ್ಪಾದಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಲೇಜಿ ಇಟರೇಟರ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇವು ಸೂಕ್ತವಾಗಿವೆ. ಒಂದೇ ಬಾರಿಗೆ ಸಂಪೂರ್ಣ ಅರೇಯನ್ನು ರಚಿಸುವ ಬದಲು, ಜನರೇಟರ್ ಮೌಲ್ಯಗಳನ್ನು ಒಂದೊಂದಾಗಿ, ವಿನಂತಿಸಿದಾಗ ಮಾತ್ರ ನೀಡುತ್ತದೆ (yield). ಇದು ಸ್ಟ್ರೀಮ್ ಪ್ರಕ್ರಿಯೆಯ ಒಂದು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ.

            function* processData(data) {
  for (const item of data) {
    if (isValid(item)) {
      yield transform(item);
    }
  }
}

const data = fetchData();
const processedIterator = processData(data);

let count = 0;
for (const item of processedIterator) {
  console.log(item);
  count++;
  if (count >= 10) break; // Take only the first 10
}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, processData ಜನರೇಟರ್ ಫಂಕ್ಷನ್ data ಅರೇಯ ಮೂಲಕ ಇಟರೇಟ್ ಮಾಡುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಐಟಂಗಾಗಿ, ಅದು ಮಾನ್ಯವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಹಾಗಿದ್ದಲ್ಲಿ, ರೂಪಾಂತರಿಸಿದ ಮೌಲ್ಯವನ್ನು ನೀಡುತ್ತದೆ. yield ಕೀವರ್ಡ್ ಫಂಕ್ಷನ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಮುಂದಿನ ಬಾರಿ ಇಟರೇಟರ್‌ನ next() ಮೆಥಡ್ ಅನ್ನು ಕರೆದಾಗ (for...of ಲೂಪ್‌ನಿಂದ ಪರೋಕ್ಷವಾಗಿ), ಫಂಕ್ಷನ್ ಅದು ನಿಲ್ಲಿಸಿದ ಸ್ಥಳದಿಂದ ಪುನರಾರಂಭಗೊಳ್ಳುತ್ತದೆ. ಮುಖ್ಯವಾಗಿ, ಯಾವುದೇ ಮಧ್ಯಂತರ ಅರೇಗಳು ರಚನೆಯಾಗುವುದಿಲ್ಲ. ಮೌಲ್ಯಗಳು ಬೇಡಿಕೆಯ ಮೇಲೆ ಉತ್ಪಾದಿಸಲ್ಪಡುತ್ತವೆ ಮತ್ತು ಬಳಸಲ್ಪಡುತ್ತವೆ.

2. ಕಸ್ಟಮ್ ಇಟರೇಟರ್‌ಗಳು

ಅದೇ ರೀತಿಯ ಲೇಜಿ ಇವ್ಯಾಲ್ಯುಯೇಷನ್ ಅನ್ನು ಸಾಧಿಸಲು ನೀವು @@iterator ಮೆಥಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕಸ್ಟಮ್ ಇಟರೇಟರ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ಇದು ಇಟರೇಷನ್ ಪ್ರಕ್ರಿಯೆಯ ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸುತ್ತದೆ ಆದರೆ ಜನರೇಟರ್‌ಗಳಿಗೆ ಹೋಲಿಸಿದರೆ ಹೆಚ್ಚು ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಕೋಡ್ ಅಗತ್ಯವಿರುತ್ತದೆ.

            function createDataProcessor(data) {
  return {
    [Symbol.iterator]() {
      let index = 0;
      return {
        next() {
          while (index < data.length) {
            const item = data[index++];
            if (isValid(item)) {
              return { value: transform(item), done: false };
            }
          }
          return { value: undefined, done: true };
        }
      };
    }
  };
}

const data = fetchData();
const processedIterable = createDataProcessor(data);

let count = 0;
for (const item of processedIterable) {
  console.log(item);
  count++;
  if (count >= 10) break;
}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು createDataProcessor ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಅದು ಇಟರೇಬಲ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. @@iterator ಮೆಥಡ್ ಒಂದು ಇಟರೇಟರ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅದರ next() ಮೆಥಡ್ ಡೇಟಾವನ್ನು ಬೇಡಿಕೆಯ ಮೇಲೆ ಫಿಲ್ಟರ್ ಮತ್ತು ರೂಪಾಂತರಿಸುತ್ತದೆ, ಜನರೇಟರ್ ವಿಧಾನದಂತೆಯೇ.

3. ಟ್ರಾನ್ಸ್‌ಡ್ಯೂಸರ್‌ಗಳು

ಟ್ರಾನ್ಸ್‌ಡ್ಯೂಸರ್‌ಗಳು ಮೆಮೊರಿ-ದಕ್ಷ ರೀತಿಯಲ್ಲಿ ಡೇಟಾ ರೂಪಾಂತರಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಹೆಚ್ಚು ಸುಧಾರಿತ ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ತಂತ್ರವಾಗಿದೆ. ಅವು ರಿಡಕ್ಷನ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅಮೂರ್ತಗೊಳಿಸುತ್ತವೆ, ಡೇಟಾದ ಮೇಲೆ ಒಂದೇ ಪಾಸ್‌ನಲ್ಲಿ ಬಹು ರೂಪಾಂತರಗಳನ್ನು (ಉದಾಹರಣೆಗೆ, ಫಿಲ್ಟರ್, ಮ್ಯಾಪ್, ರಿಡ್ಯೂಸ್) ಸಂಯೋಜಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ಮಧ್ಯಂತರ ಅರೇಗಳ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ಟ್ರಾನ್ಸ್‌ಡ್ಯೂಸರ್‌ಗಳ ಸಂಪೂರ್ಣ ವಿವರಣೆಯು ಈ ಲೇಖನದ ವ್ಯಾಪ್ತಿಯನ್ನು ಮೀರಿದ್ದರೂ, ಕಾಲ್ಪನಿಕ transduce ಫಂಕ್ಷನ್ ಬಳಸಿಕೊಂಡು ಒಂದು ಸರಳೀಕೃತ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

            // Assuming a transduce library is available (e.g., Ramda, Transducers.js)
import { map, filter, transduce, toArray } from 'transducers-js';

const data = fetchData();

const transducer = compose(
  filter(isValid),
  map(transform)
);

const processedData = transduce(transducer, toArray, [], data);

const firstTen = processedData.slice(0, 10); // Take only the first 10

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, filter ಮತ್ತು map ಗಳು compose ಫಂಕ್ಷನ್ (ಸಾಮಾನ್ಯವಾಗಿ ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಲೈಬ್ರರಿಗಳಿಂದ ಒದಗಿಸಲ್ಪಡುತ್ತದೆ) ಬಳಸಿ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟ ಟ್ರಾನ್ಸ್‌ಡ್ಯೂಸರ್ ಫಂಕ್ಷನ್‌ಗಳಾಗಿವೆ. transduce ಫಂಕ್ಷನ್ ಸಂಯೋಜಿತ ಟ್ರಾನ್ಸ್‌ಡ್ಯೂಸರ್ ಅನ್ನು data ಅರೇಗೆ ಅನ್ವಯಿಸುತ್ತದೆ, ಫಲಿತಾಂಶಗಳನ್ನು ಅರೇಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು toArray ಅನ್ನು ರಿಡಕ್ಷನ್ ಫಂಕ್ಷನ್ ಆಗಿ ಬಳಸುತ್ತದೆ. ಇದು ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಮ್ಯಾಪಿಂಗ್ ಹಂತಗಳಲ್ಲಿ ಮಧ್ಯಂತರ ಅರೇ ರಚನೆಯನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

ಗಮನಿಸಿ: ಟ್ರಾನ್ಸ್‌ಡ್ಯೂಸರ್ ಲೈಬ್ರರಿಯ ಆಯ್ಕೆಯು ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳು ಮತ್ತು ಪ್ರಾಜೆಕ್ಟ್ ಅವಲಂಬನೆಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಬಂಡಲ್ ಗಾತ್ರ, ಕಾರ್ಯಕ್ಷಮತೆ, ಮತ್ತು API ಪರಿಚಿತತೆಯಂತಹ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸಿ.

4. ಲೇಜಿ ಇವ್ಯಾಲ್ಯುಯೇಷನ್ ಒದಗಿಸುವ ಲೈಬ್ರರಿಗಳು

ಹಲವಾರು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗಳು ಲೇಜಿ ಇವ್ಯಾಲ್ಯುಯೇಷನ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಸ್ಟ್ರೀಮ್ ಪ್ರಕ್ರಿಯೆ ಮತ್ತು ಮೆಮೊರಿ ಆಪ್ಟಿಮೈಸೇಶನ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತವೆ. ಈ ಲೈಬ್ರರಿಗಳು ಇಟರೇಟರ್‌ಗಳು ಅಥವಾ ಅಬ್ಸರ್ವೇಬಲ್‌ಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಚೈನ್ ಮಾಡಬಹುದಾದ ಮೆಥಡ್‌ಗಳನ್ನು ನೀಡುತ್ತವೆ, ಮಧ್ಯಂತರ ಅರೇಗಳ ರಚನೆಯನ್ನು ತಪ್ಪಿಸುತ್ತವೆ.

• Lodash: ತನ್ನ ಚೈನ್ ಮಾಡಬಹುದಾದ ಮೆಥಡ್‌ಗಳ ಮೂಲಕ ಲೇಜಿ ಇವ್ಯಾಲ್ಯುಯೇಷನ್ ಅನ್ನು ನೀಡುತ್ತದೆ. ಲೇಜಿ ಅನುಕ್ರಮವನ್ನು ಪ್ರಾರಂಭಿಸಲು _.chain ಬಳಸಿ.
• Lazy.js: ಸಂಗ್ರಹಗಳ ಲೇಜಿ ಇವ್ಯಾಲ್ಯುಯೇಷನ್‌ಗಾಗಿ ವಿಶೇಷವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.
• RxJS: ಅಸಮಕಾಲಿಕ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳಿಗಾಗಿ ಅಬ್ಸರ್ವೇಬಲ್‌ಗಳನ್ನು ಬಳಸುವ ಒಂದು ರಿಯಾಕ್ಟಿವ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಲೈಬ್ರರಿ.

Lodash ಬಳಸುವ ಉದಾಹರಣೆ:

            import _ from 'lodash';

const data = fetchData();

const processedData = _(data)
  .filter(isValid)
  .map(transform)
  .take(10)
  .value();

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, _.chain ಒಂದು ಲೇಜಿ ಅನುಕ್ರಮವನ್ನು ರಚಿಸುತ್ತದೆ. filter, map, ಮತ್ತು take ಮೆಥಡ್‌ಗಳು ಲೇಜಿಯಾಗಿ ಅನ್ವಯಿಸಲ್ಪಡುತ್ತವೆ, ಅಂದರೆ ಅವು ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಲು .value() ಮೆಥಡ್ ಅನ್ನು ಕರೆದಾಗ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತವೆ. ಇದು ಮಧ್ಯಂತರ ಅರೇಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳೊಂದಿಗೆ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಮೇಲೆ ಚರ್ಚಿಸಿದ ತಂತ್ರಗಳ ಜೊತೆಗೆ, ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸಲು ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:

1. ಸಂಸ್ಕರಿಸಿದ ಡೇಟಾದ ಗಾತ್ರವನ್ನು ಸೀಮಿತಗೊಳಿಸಿ

ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ, ನೀವು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಡೇಟಾದ ಗಾತ್ರವನ್ನು ಅಗತ್ಯವಿರುವಷ್ಟಕ್ಕೆ ಮಾತ್ರ ಸೀಮಿತಗೊಳಿಸಿ. ಉದಾಹರಣೆಗೆ, ನೀವು ಕೇವಲ ಮೊದಲ 10 ಫಲಿತಾಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕಾದರೆ, ಇತರ ರೂಪಾಂತರಗಳನ್ನು ಅನ್ವಯಿಸುವ ಮೊದಲು ಡೇಟಾದ ಅಗತ್ಯವಿರುವ ಭಾಗವನ್ನು ಮಾತ್ರ ತೆಗೆದುಕೊಳ್ಳಲು slice ಮೆಥಡ್ ಅಥವಾ ಅಂತಹುದೇ ತಂತ್ರವನ್ನು ಬಳಸಿ.

2. ಅನಗತ್ಯ ಡೇಟಾ ನಕಲನ್ನು ತಪ್ಪಿಸಿ

ಅನಪೇಕ್ಷಿತವಾಗಿ ಡೇಟಾವನ್ನು ನಕಲು ಮಾಡಬಹುದಾದ ಕಾರ್ಯಾಚರಣೆಗಳ ಬಗ್ಗೆ ಗಮನವಿರಲಿ. ಉದಾಹರಣೆಗೆ, ದೊಡ್ಡ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಥವಾ ಅರೇಗಳ ಪ್ರತಿಗಳನ್ನು ರಚಿಸುವುದು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚಿಸಬಹುದು. ಆಬ್ಜೆಕ್ಟ್ ಡಿಸ್ಟ್ರಕ್ಚರಿಂಗ್ ಅಥವಾ ಅರೇ ಸ್ಲೈಸಿಂಗ್‌ನಂತಹ ತಂತ್ರಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸಿ.

3. ಕ್ಯಾಶಿಂಗ್‌ಗಾಗಿ ವೀಕ್‌ಮ್ಯಾಪ್‌ಗಳು ಮತ್ತು ವೀಕ್‌ಸೆಟ್‌ಗಳನ್ನು ಬಳಸಿ

ನೀವು ದುಬಾರಿ ಗಣನೆಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಕ್ಯಾಶ್ ಮಾಡಬೇಕಾದರೆ, WeakMap ಅಥವಾ WeakSet ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಈ ಡೇಟಾ ರಚನೆಗಳು ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಟ್ ಮಾಡುವುದನ್ನು ತಡೆಯದೆ ಡೇಟಾವನ್ನು ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಸಂಬಂಧಿತ ಆಬ್ಜೆಕ್ಟ್ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವವರೆಗೆ ಮಾತ್ರ ಕ್ಯಾಶ್ ಮಾಡಿದ ಡೇಟಾ ಅಗತ್ಯವಿದ್ದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

4. ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡಿ

ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿನ ಮೆಮೊರಿ ಲೀಕ್‌ಗಳು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಲು ಬ್ರೌಸರ್ ಡೆವಲಪರ್ ಪರಿಕರಗಳು ಅಥವಾ Node.js ಪ್ರೊಫೈಲಿಂಗ್ ಪರಿಕರಗಳನ್ನು ಬಳಸಿ. ಮೆಮೊರಿಯನ್ನು ಅತಿಯಾಗಿ ಹಂಚಿಕೆ ಮಾಡಲಾಗುತ್ತಿರುವ ಅಥವಾ ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಷನ್‌ಗೆ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತಿರುವ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು ಪ್ರೊಫೈಲಿಂಗ್ ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

5. ಕ್ಲೋಸರ್ ಸ್ಕೋಪ್ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ

ಕ್ಲೋಸರ್‌ಗಳು ತಮ್ಮ ಸುತ್ತಮುತ್ತಲಿನ ಸ್ಕೋಪ್‌ನಿಂದ ಅಚಾನಕ್ಕಾಗಿ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಸೆರೆಹಿಡಿಯಬಹುದು, ಅವುಗಳನ್ನು ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಟ್ ಮಾಡುವುದನ್ನು ತಡೆಯಬಹುದು. ನೀವು ಕ್ಲೋಸರ್‌ಗಳೊಳಗೆ ಬಳಸುವ ವೇರಿಯೇಬಲ್‌ಗಳ ಬಗ್ಗೆ ಗಮನವಿರಲಿ ಮತ್ತು ದೊಡ್ಡ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಥವಾ ಅರೇಗಳನ್ನು ಅನಗತ್ಯವಾಗಿ ಸೆರೆಹಿಡಿಯುವುದನ್ನು ತಪ್ಪಿಸಿ. ಮೆಮೊರಿ ಲೀಕ್‌ಗಳನ್ನು ತಡೆಗಟ್ಟಲು ವೇರಿಯೇಬಲ್ ಸ್ಕೋಪ್ ಅನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಬಹಳ ಮುಖ್ಯ.

6. ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿ

ನೀವು ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ಗಳು ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕಗಳಂತಹ ಸ್ಪಷ್ಟವಾದ ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆ ಅಗತ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಅವುಗಳು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಈ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಹಾಗೆ ಮಾಡಲು ವಿಫಲವಾದರೆ ಸಂಪನ್ಮೂಲ ಸೋರಿಕೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಕುಗ್ಗಿಸಬಹುದು.

7. ವೆಬ್ ವರ್ಕರ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ

ಗಣನಾತ್ಮಕವಾಗಿ ತೀವ್ರವಾದ ಕಾರ್ಯಗಳಿಗಾಗಿ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರತ್ಯೇಕ ಥ್ರೆಡ್‌ಗೆ ಆಫ್‌ಲೋಡ್ ಮಾಡಲು ವೆಬ್ ವರ್ಕರ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಇದು ಮುಖ್ಯ ಥ್ರೆಡ್ ನಿರ್ಬಂಧಿಸುವುದನ್ನು ತಡೆಯಬಹುದು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು. ವೆಬ್ ವರ್ಕರ್‌ಗಳು ತಮ್ಮದೇ ಆದ ಮೆಮೊರಿ ಜಾಗವನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಆದ್ದರಿಂದ ಅವು ಮುಖ್ಯ ಥ್ರೆಡ್‌ನ ಮೆಮೊರಿ ಫುಟ್‌ಪ್ರಿಂಟ್‌ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರದೆ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು.

ಉದಾಹರಣೆ: ದೊಡ್ಡ CSV ಫೈಲ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು

ನೀವು ಲಕ್ಷಾಂತರ ಸಾಲುಗಳನ್ನು ಹೊಂದಿರುವ ದೊಡ್ಡ CSV ಫೈಲ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬೇಕಾದ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸಿ. ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಒಂದೇ ಬಾರಿಗೆ ಮೆಮೊರಿಗೆ ಓದುವುದು ಅವ್ಯಾವಹಾರಿಕವಾಗಿರುತ್ತದೆ. ಬದಲಾಗಿ, ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ನೀವು ಫೈಲ್ ಅನ್ನು ಸಾಲು ಸಾಲಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸ್ಟ್ರೀಮಿಂಗ್ ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು.

Node.js ಮತ್ತು readline ಮಾಡ್ಯೂಲ್ ಬಳಸಿ:

            const fs = require('fs');
const readline = require('readline');

async function processCSV(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity // Recognize all instances of CR LF
  });

  for await (const line of rl) {
    // Process each line of the CSV file
    const data = parseCSVLine(line); // Assume parseCSVLine function exists

    if (isValid(data)) {
      const transformedData = transform(data);
      console.log(transformedData);
    }
  }
}

processCSV('large_data.csv');

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು CSV ಫೈಲ್ ಅನ್ನು ಸಾಲು ಸಾಲಾಗಿ ಓದಲು readline ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. for await...of ಲೂಪ್ ಪ್ರತಿ ಸಾಲಿನ ಮೇಲೆ ಇಟರೇಟ್ ಮಾಡುತ್ತದೆ, ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡದೆಯೇ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಪ್ರತಿ ಸಾಲನ್ನು ಪಾರ್ಸ್ ಮಾಡಲಾಗುತ್ತದೆ, ಮೌಲ್ಯೀಕರಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಲಾಗ್ ಮಾಡುವ ಮೊದಲು ರೂಪಾಂತರಿಸಲಾಗುತ್ತದೆ. ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಅರೇಗೆ ಓದುವುದಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಇದು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ತೀರ್ಮಾನ

ದಕ್ಷ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಚೈನ್ಡ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಮೆಮೊರಿ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ಜನರೇಟರ್‌ಗಳು, ಕಸ್ಟಮ್ ಇಟರೇಟರ್‌ಗಳು, ಟ್ರಾನ್ಸ್‌ಡ್ಯೂಸರ್‌ಗಳು, ಮತ್ತು ಲೇಜಿ ಇವ್ಯಾಲ್ಯುಯೇಷನ್ ಲೈಬ್ರರಿಗಳಂತಹ ಸ್ಟ್ರೀಮ್ ಪ್ರಕ್ರಿಯೆ ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು. ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡಲು, ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಮತ್ತು ಗಣನಾತ್ಮಕವಾಗಿ ತೀವ್ರವಾದ ಕಾರ್ಯಗಳಿಗಾಗಿ ವೆಬ್ ವರ್ಕರ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಲು ಮರೆಯದಿರಿ. ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನೀವು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸುವ ಮತ್ತು ವಿವಿಧ ಸಾಧನಗಳು ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಲ್ಲಿ ಸುಗಮ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಒದಗಿಸುವ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಬಳಕೆಯ ಸಂದರ್ಭಗಳಿಗೆ ಈ ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಲು ಮರೆಯದಿರಿ ಮತ್ತು ಕೋಡ್ ಸಂಕೀರ್ಣತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಲಾಭಗಳ ನಡುವಿನ ವಿನಿಮಯವನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸಿ. ಅತ್ಯುತ್ತಮ ವಿಧಾನವು ನಿಮ್ಮ ಡೇಟಾದ ಗಾತ್ರ ಮತ್ತು ರಚನೆ, ಹಾಗೆಯೇ ನಿಮ್ಮ ಗುರಿ ಪರಿಸರದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ.